//package kt.flows
//
//import kotlinx.coroutines.*
//
//
///**
// * 2
// * 取消与超时
// *
// * 1,取消
// * cancel   join
// * [cancelCoroutinesJoin]
// *
// *
// *
// * 2, cancelAndJoin
// *
// * [cancelJoinTryCatchShow]
// * [cancelJoinIsActive]
// *
// * 3,
// * [cancelTryFinally]
// *
// *
// * 4,finally中释放资源
// * [cancelTryFinally]
// *
// *
// * 5,运行不能取消的代码块
// * [cancelCannotCode]
// *
// * 6,超时
// * [timeoutShow]
// *
// *
// */
//fun main() {
//
////    cancelCoroutinesJoin()
////    cancelJoinFunShow()
////    cancelJoinTryCatchShow()
////    cancelJoinIsActive()
////    cancelTryFinally()
////    cancelCannotCode()
////    timeoutShow()
////    timeoutUpdateShow()
//    closeResouceShowDemo()
//
//
//}
//
//
//
////------------------------------------------------
////------------------------------------------------
////------------------------------------------------
//
//var acquired = 0
//
//class Resource {
//    init { acquired++ } // Acquire the resource
//    fun close() { acquired-- } // Release the resource
//}
//
//
//fun closeResouceShowDemo(){
//    runBlocking {
//        repeat(10_000) { // Launch 10K coroutines
//            launch {
//                var resource: Resource? = null // Not acquired yet
//                try {
//                    withTimeout(60) { // Timeout of 60 ms
//                        delay(50) // Delay for 50 ms
//                        resource = Resource() // Store a resource to the variable if acquired
//                    }
//                    // We can do something else with the resource here
//                } finally {
//                    resource?.close() // Release the resource if it was acquired
//                }
//            }
//        }
//    }
//    println(acquired) // Print the number of resources still acquired
//
//}
//
//
//
//
//
//
//
////------------------------------------------------
//
//
//fun timeoutUpdateShow(){
//    runBlocking {
//        val result = withTimeoutOrNull(1300L) {
//            repeat(1000) { i ->
//                println("I'm sleeping $i ...")
//                delay(500L)
//            }
//            "Done" // 在它运行得到结果之前取消它
//        }
//        println("Result is $result")
//    }
//
//}
//
///*
//I'm sleeping 0 ...
//I'm sleeping 1 ...
//I'm sleeping 2 ...
//Result is null
//
// */
//
//
//
//
//
//fun timeoutShow(){
//    runBlocking {
//        withTimeout(1300L) {
//            repeat(1000) { i ->
//                println("I'm sleeping $i ...  ${Thread.currentThread().name}")
//                delay(500L)
//            }
//        }
//
//    }
//}
//
///*
//
//I'm sleeping 0 ...
//I'm sleeping 1 ...
//I'm sleeping 2 ...
//Exception in thread "main" kotlinx.coroutines.TimeoutCancellationException: Timed out waiting for 1300 ms
//	at kotlinx.coroutines.TimeoutKt.TimeoutCancellationException(Timeout.kt:184)
//	at kotlinx.coroutines.TimeoutCoroutine.run(Timeout.kt:154)
//	at kotlinx.coroutines.EventLoopImplBase$DelayedRunnableTask.run(EventLoop.common.kt:508)
//	at kotlinx.coroutines.EventLoopImplBase.processNextEvent(EventLoop.common.kt:284)
//	at kotlinx.coroutines.DefaultExecutor.run(DefaultExecutor.kt:108)
//	at java.lang.Thread.run(Thread.java:745)
//
//
//
// */
//
//
//
////------------------------------------------------
//
//fun cancelCannotCode(){
//    runBlocking {
//
//        val job = launch {
//            try {
//                repeat(1000) { i ->
//                    println("job: I'm sleeping $i ...")
//                    delay(500L)
//                }
//            } finally {
//                withContext(NonCancellable) {
//                    println("job: I'm running finally")
//                    delay(1000L)
//                    println("job: And I've just delayed for 1 sec because I'm non-cancellable")
//                }
//            }
//        }
//
//        delay(1300L) // 延迟一段时间
//        println("main: I'm tired of waiting!")
//        job.cancelAndJoin() // 取消该作业并等待它结束
//        println("main: Now I can quit.")
//
//    }
//
//}
//
//
///*
//
//job: I'm sleeping 0 ...
//job: I'm sleeping 1 ...
//job: I'm sleeping 2 ...
//main: I'm tired of waiting!
//job: I'm running finally
//job: And I've just delayed for 1 sec because I'm non-cancellable
//main: Now I can quit.
//
//
// */
//
//
//
//
//
////------------------------------------------------
//fun cancelTryFinally() {
//    runBlocking {
//        val job = launch {
//            try {
//                repeat(1000) { i ->
//                    println("job: I'm sleeping $i ...")
//                    delay(500L)
//                }
//            } finally {
//                println("job: I'm running finally")
//            }
//        }
//
//        delay(1300L) // 延迟一段时间
//        println("main: I'm tired of waiting!")
//
//        job.cancelAndJoin() // 取消该作业并且等待它结束
//        println("main: Now I can quit.")
//    }
//}
//
///*
//
//job: I'm sleeping 0 ...
//job: I'm sleeping 1 ...
//job: I'm sleeping 2 ...
//main: I'm tired of waiting!
//job: I'm running finally
//main: Now I can quit.
//
//
// */
//
//
////------------------------------------------------
//fun cancelJoinIsActive(){
//    runBlocking {
//        val startTime = System.currentTimeMillis()
//
//        val job = launch(Dispatchers.Default) {
//            var nextPrintTime = startTime
//            var i = 0
//            while (isActive) { // 可以被取消的计算循环
//                // 每秒打印消息两次
//                if (System.currentTimeMillis() >= nextPrintTime) {
//                    println("job: I'm sleeping ${i++} ...")
//                    nextPrintTime += 500L
//                }
//            }
//        }
//
//        delay(1300L) // 等待一段时间
//        println("main: I'm tired of waiting!")
//
//        job.cancelAndJoin() // 取消该作业并等待它结束
//        println("main: Now I can quit.")
//    }
//}
//
///*
//job: I'm sleeping 0 ...
//job: I'm sleeping 1 ...
//job: I'm sleeping 2 ...
//main: I'm tired of waiting!
//main: Now I can quit.
//
// */
//
//
//
//fun cancelJoinTryCatchShow(){
//    runBlocking {
//
//        val job = launch(Dispatchers.Default) {
//            repeat(5) { i ->
//                try {
//                    // print a message twice a second
//                    println("job: I'm sleeping $i ...  isActive = $isActive")
//                    delay(500)
//                } catch (e: Exception) {
//                    // log the exception
//                    println(e)
//                }
//            }
//        }
//        println("start delay .. ")
//        delay(1300L) // delay a bit
//        println("main: I'm tired of waiting!")
//        job.cancelAndJoin() // cancels the job and waits for its completion
//        println("main: Now I can quit.")
//    }
//
//}
//
//
///*
//
//               start delay ..
//                job: I'm sleeping 0 ...  isActive = true
//                job: I'm sleeping 1 ...  isActive = true
//                job: I'm sleeping 2 ...  isActive = true
//
//                main: I'm tired of waiting!
//                kotlinx.coroutines.JobCancellationException: StandaloneCoroutine was cancelled; job=StandaloneCoroutine{Cancelling}@77ecbd6d
//                job: I'm sleeping 3 ...  isActive = false
//                kotlinx.coroutines.JobCancellationException: StandaloneCoroutine was cancelled; job=StandaloneCoroutine{Cancelling}@77ecbd6d
//                job: I'm sleeping 4 ...  isActive = false
//                kotlinx.coroutines.JobCancellationException: StandaloneCoroutine was cancelled; job=StandaloneCoroutine{Cancelling}@77ecbd6d
//                main: Now I can quit.
//
// */
//
//
//
//
////------------------------------------------------
//
//
//fun cancelJoinFunShow(){
//    runBlocking {
//
//        val startTime = System.currentTimeMillis()
//
//        val job = launch(Dispatchers.Default) {
//            var nextPrintTime = startTime
//            var i = 0
//            while (i < 5) { // 一个执行计算的循环，只是为了占用 CPU
//                // 每秒打印消息两次
//                if (System.currentTimeMillis() >= nextPrintTime) {
//                    println("job: I'm sleeping ${i++} ...")
//                    nextPrintTime += 500L
//                }
//            }
//        }
//
//        delay(1300L) // 等待一段时间
//        println("main: I'm tired of waiting!")
//
//        job.cancelAndJoin() // 取消一个作业并且等待它结束
//        println("main: Now I can quit.")
//    }
//
//}
///*
//                    job: I'm sleeping 0 ...
//                    job: I'm sleeping 1 ...
//                    job: I'm sleeping 2 ...
//                    main: I'm tired of waiting!
//                    job: I'm sleeping 3 ...
//                    job: I'm sleeping 4 ...
//                    main: Now I can quit.
// */
//
//
//
////------------------------------------------------
//
//fun cancelCoroutinesJoin(){
//    runBlocking {
//        var job = launch{
//            repeat(100){ i ->
//                println("job : i'm sleeping $i")
//                delay(500L)
//            }
//        }
//
//        delay(1300L)
//        println("main I'm tired of waiting ...  ")
//        job.cancel()    // 取消
////        job.join()     //等待作业执行结束
//        println("main now can quit..")
//
//
//    }
//
//}
///*
//        job : i'm sleeping 0
//        job : i'm sleeping 1
//        job : i'm sleeping 2                        //
//        main I'm tired of waiting ...
//        main now can quit..
//
// */
//
//
////------------------------------------------------